import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { socketManager } from '@/utils/socketManager'
import { userOnlineApi } from '@/api/userOnline'

/**
 * 用户在线状态Store
 */
export const useUserOnlineStore = defineStore('userOnline', () => {
  // ==================== 状态定义 ====================
  
  // 在线用户列表
  const onlineUsers = ref<Array<{
    userId: number
    lastActiveTime: string
    isOnline: boolean
  }>>([])
  
  // 在线用户数量
  const onlineUserCount = ref(0)
  
  // 用户状态缓存
  const userStatusCache = ref<Map<number, {
    status: string
    updateTime: string
    isOnline: boolean
  }>>(new Map())
  
  // 加载状态
  const loading = ref(false)
  const error = ref<string | null>(null)
  
  // ==================== 计算属性 ====================
  
  // 在线用户ID列表
  const onlineUserIds = computed(() => {
    return onlineUsers.value.map(user => user.userId)
  })
  
  // 是否有在线用户
  const hasOnlineUsers = computed(() => {
    return onlineUserCount.value > 0
  })
  
  // ==================== Socket.IO 事件处理 ====================
  
  /**
   * 初始化Socket.IO事件监听
   */
  const initSocketListeners = () => {
    // 监听用户状态变化
    socketManager.onOnlineStatusChange('userOnlineStore', (data: any) => {
      handleSocketEvent(data)
    })
  }
  
  /**
   * 处理Socket.IO事件
   */
  const handleSocketEvent = (data: any) => {
    if (data.type === 'onlineUsersList') {
      // 在线用户列表更新
      updateOnlineUsersList(data.data)
    } else if (data.type === 'userStatusResponse') {
      // 用户状态响应
      updateUserStatus(data.data.userId, data.data.status)
    } else if (data.userId && data.status) {
      // 用户状态变化
      handleUserStatusChange(data.userId, data.status, data.onlineUserCount)
    }
  }
  
  /**
   * 处理用户状态变化
   */
  const handleUserStatusChange = (userId: number, status: string, totalCount?: number) => {
    console.log(`👤 用户 ${userId} 状态变化: ${status}`)
    
    if (status === 'ONLINE') {
      // 用户上线
      addOnlineUser(userId)
    } else if (status === 'OFFLINE') {
      // 用户下线
      removeOnlineUser(userId)
    }
    
    // 更新用户状态缓存
    userStatusCache.value.set(userId, {
      status,
      updateTime: new Date().toISOString(),
      isOnline: status === 'ONLINE'
    })
    
    // 更新总数
    if (typeof totalCount === 'number') {
      onlineUserCount.value = totalCount
    }
  }
  
  /**
   * 更新在线用户列表
   */
  const updateOnlineUsersList = (data: { onlineUsers: any[], totalCount: number }) => {
    onlineUsers.value = data.onlineUsers
    onlineUserCount.value = data.totalCount
    
    // 更新用户状态缓存
    data.onlineUsers.forEach(user => {
      userStatusCache.value.set(user.userId, {
        status: 'ONLINE',
        updateTime: user.lastActiveTime,
        isOnline: true
      })
    })
  }
  
  /**
   * 添加在线用户
   */
  const addOnlineUser = (userId: number) => {
    const existingIndex = onlineUsers.value.findIndex(user => user.userId === userId)
    if (existingIndex === -1) {
      onlineUsers.value.push({
        userId,
        lastActiveTime: new Date().toISOString(),
        isOnline: true
      })
      onlineUserCount.value = onlineUsers.value.length
    }
  }
  
  /**
   * 移除在线用户
   */
  const removeOnlineUser = (userId: number) => {
    const index = onlineUsers.value.findIndex(user => user.userId === userId)
    if (index !== -1) {
      onlineUsers.value.splice(index, 1)
      onlineUserCount.value = onlineUsers.value.length
    }
  }
  
  /**
   * 更新用户状态
   */
  const updateUserStatus = (userId: number, status: any) => {
    userStatusCache.value.set(userId, {
      status: status.status || 'OFFLINE',
      updateTime: status.updateTime || new Date().toISOString(),
      isOnline: status.isOnline || false
    })
  }
  
  // ==================== API 方法 ====================
  
  /**
   * 获取在线用户列表
   */
  const fetchOnlineUsers = async () => {
    try {
      loading.value = true
      error.value = null
      
      const response = await userOnlineApi.getOnlineUsers()
      if (response.success) {
        onlineUsers.value = response.data
        onlineUserCount.value = response.totalCount
        
        // 更新缓存
        response.data.forEach((user: any) => {
          userStatusCache.value.set(user.userId, {
            status: 'ONLINE',
            updateTime: user.lastActiveTime,
            isOnline: true
          })
        })
      }
    } catch (err: any) {
      error.value = err.message || '获取在线用户列表失败'
      console.error('❌ 获取在线用户列表失败:', err)
    } finally {
      loading.value = false
    }
  }
  
  /**
   * 获取在线用户数量
   */
  const fetchOnlineUserCount = async () => {
    try {
      const response = await userOnlineApi.getOnlineUserCount()
      if (response.success) {
        onlineUserCount.value = response.data
      }
    } catch (err: any) {
      console.error('❌ 获取在线用户数量失败:', err)
    }
  }
  
  /**
   * 检查用户是否在线
   */
  const checkUserOnline = async (userId: number) => {
    try {
      const response = await userOnlineApi.checkUserOnline(userId)
      if (response.success) {
        const userData = response.data
        userStatusCache.value.set(userId, {
          status: userData.status.status || 'OFFLINE',
          updateTime: userData.status.updateTime || new Date().toISOString(),
          isOnline: userData.isOnline
        })
        return userData.isOnline
      }
      return false
    } catch (err: any) {
      console.error('❌ 检查用户在线状态失败:', err)
      return false
    }
  }
  
  /**
   * 通过Socket获取在线用户列表
   */
  const getOnlineUsersViaSocket = () => {
    socketManager.getOnlineUsers()
  }
  
  /**
   * 通过Socket获取用户状态
   */
  const getUserStatusViaSocket = (userId: number) => {
    socketManager.getUserStatus(userId)
  }
  
  // ==================== 工具方法 ====================
  
  /**
   * 检查用户是否在线（从缓存）
   */
  const isUserOnline = (userId: number): boolean => {
    const userStatus = userStatusCache.value.get(userId)
    return userStatus?.isOnline || false
  }
  
  /**
   * 获取用户状态（从缓存）
   */
  const getUserStatus = (userId: number) => {
    return userStatusCache.value.get(userId) || {
      status: 'OFFLINE',
      updateTime: new Date().toISOString(),
      isOnline: false
    }
  }
  
  /**
   * 清理缓存
   */
  const clearCache = () => {
    onlineUsers.value = []
    onlineUserCount.value = 0
    userStatusCache.value.clear()
    error.value = null
  }
  
  /**
   * 清理Socket监听器
   */
  const cleanup = () => {
    socketManager.offOnlineStatusChange('userOnlineStore')
    clearCache()
  }
  
  return {
    // 状态
    onlineUsers,
    onlineUserCount,
    userStatusCache,
    loading,
    error,
    
    // 计算属性
    onlineUserIds,
    hasOnlineUsers,
    
    // 方法
    initSocketListeners,
    fetchOnlineUsers,
    fetchOnlineUserCount,
    checkUserOnline,
    getOnlineUsersViaSocket,
    getUserStatusViaSocket,
    isUserOnline,
    getUserStatus,
    clearCache,
    cleanup
  }
})
